Principio de Segregación de Interfaces (ISP)

(Interface Segregation Principle)

Introducción

El Principio de Segregación de Interfaces, parte fundamental de SOLID, sostiene que “los clientes no deben verse forzados a depender de interfaces que no utilizan”.
En otras palabras: es mejor tener varias interfaces específicas que una sola interfaz general y pesada. Cada interfaz debería ser lo más pequeña y enfocada posible, adaptada a las necesidades reales de los clientes.

¿Por qué es importante?

Ventaja	Impacto
Simplicidad	Los clientes interactúan solo con los métodos que realmente necesitan.
Flexibilidad	Permite cambios o ampliaciones en partes específicas del sistema sin afectar a otros módulos.
Menor acoplamiento	Reduce dependencias innecesarias entre clases no relacionadas.
Fácil mantenimiento	Cuando una interfaz cambia, afecta solo a quienes realmente la usan.

Ejemplo: violación del ISP

Una interfaz demasiado grande:

public interface Worker {
    void work();
    void eat();
}

Clases que implementan:

public class OfficeWorker implements Worker {
    public void work() { /* trabaja en oficina */ }
    public void eat() { /* almuerza */ }
}

public class RobotWorker implements Worker {
    public void work() { /* trabaja 24/7 */ }
    public void eat() {
        throw new UnsupportedOperationException("Robots don't eat.");
    }
}

Problema

RobotWorker se ve forzado a implementar un método eat() que no tiene sentido para su naturaleza. Esto es una violación del ISP.

Ejemplo correcto aplicando ISP

Dividimos en interfaces más específicas:

public interface Workable {
    void work();
}

public interface Eatable {
    void eat();
}

Ahora:

public class OfficeWorker implements Workable, Eatable {
    public void work() { /* trabaja en oficina */ }
    public void eat() { /* almuerza */ }
}

public class RobotWorker implements Workable {
    public void work() { /* trabaja 24/7 */ }
}

Cada clase implementa solo las interfaces que realmente necesita.
RobotWorker ya no está obligado a implementar un método inútil.

Buenas prácticas para aplicar ISP

Mantén las interfaces pequeñas y enfocadas
Cada interfaz debería representar una responsabilidad única.
Divide interfaces grandes
Si ves que múltiples implementaciones solo usan parte de una interfaz, es hora de dividirla.
Apóyate en el principio de "rol"
Piensa en las interfaces como representaciones de “roles” específicos que un objeto puede desempeñar.
Preferir la composición sobre herencia múltiple
Una clase puede implementar varias interfaces pequeñas en lugar de heredar de una clase gigantesca.

Relación de ISP con otros principios

Single Responsibility Principle (SRP): ayuda a que cada interfaz tenga una responsabilidad clara.
Dependency Inversion Principle (DIP): promueve depender de interfaces pequeñas y abstraídas, no de implementaciones grandes.

Conclusión

El Principio de Segregación de Interfaces impulsa un diseño de software más limpio, modular y fácil de mantener.
Aplicarlo correctamente significa que cada módulo depende solo de lo que realmente usa, evitando dependencias innecesarias y mejorando la evolución del sistema.